#pragma once
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include<iostream>
#include<cstring>
#include<string.h>
#include <string>

namespace ns_protocol 
{
#define SPACE " "
#define SPACE_LEN strlen(SPACE)
#define SEP "\r\n"
#define SEP_LEN strlen(SEP)

    class Request
    {
    public:
    //序列化的过程就是转换为字符串的过程
        std::string Serialize()
        {
            std::string str;
            str+=std::to_string(_x);
            str+=SPACE;
            str+=std::to_string(_op);
            str+=SPACE;
            str+=std::to_string(_y);
            return str;
        }
        // std::string Serialize()
        // {
        //     std::string str;
        //     str+=std::to_string(_x);
        //     str+=SPACE;
        //     str+=std::to_string(_op);
        //     str+=SPACE;
        //     str+=std::to_string(_y);
        //     return str;
        // }
        // std::string Serialize()
        // {
        //     std::string str;
        //     str=std::to_string(_x);
        //     str+=SPACE;
        //     str+=_op;
        //     str+=SPACE;
        //     str+=std::to_string(_y);
        //     return str;
        // }
        bool Deserialize(const std::string& str)
        {
            std::size_t left=str.find(SPACE);
            if(left==std::string::npos){
                return false;
            }
            std::size_t right=str.rfind(SPACE);
            if(right==std::string::npos){
                return false;
            }
            _x=atoi(str.substr(0,left).c_str());
            _y=atoi(str.substr(right+SPACE_LEN).c_str());
            if(left+SPACE_LEN > str.size()){
                return false;
            }
            else{
                _op=str[left+SPACE_LEN];
            }
        }
        bool Desrialize(const std::string& str)
        {
            std::size_t left=str.find(str);
            if(left==std::string::npos){
                return false;
            }
            std::size_t right=str.rfind(str);
            if(right==std::string::npos){
                return false;
            }
            _x=atoi(str.substr(0,left).c_str());
            _y=atoi(str.substr(right+SPACE_LEN).c_str());
            if(left+SPACE_LEN > str.size()){
                return false;
            }
            else
            {
                _op=str[left+SPACE_LEN];
            }
            return true;
        }
    // bool Deserialize(const std::string& str)
    // {
    //     std::size_t left=str.find(SPACE);
    //     if(left==std::string::npos){
    //         return false;
    //     }
    //     std::size_t right=str.rfind(SPACE);
    //     if(right==std::string::npos){
    //         return false;
    //     }
    //     _x=atoi(str.substr(0,left).c_str());
    //     _y=atoi(str.substr(right+SPACE_LEN).c_str());
    //     if(left+SPACE_LEN > str.size()){
    //         return false;
    //     }
    //     else{
    //         _op=str[left+SPACE_LEN];
    //     }
    //     return true;
    // }
        //反序列化的过程就是将字符串的数据再转换为结构化的数据
    // bool Deserialize(const std::string& str)
    // {
    //     std::size_t left=str.find(SPACE);
    //     if(left==std::string::npos){
    //         return false;
    //     }
    //     std::size_t right=str.rfind(SPACE);
    //     if(right==std::string::npos){
    //         return false;
    //     }
    //     _x=atoi(str.substr(0,left).c_str());
    //     _y=atoi(str.substr(right+SPACE_LEN).c_str());
    //     if(left+SPACE_LEN>str.size()){
    //         return false;
    //     }
    //     else{
    //         _op=str[left+SPACE_LEN];
    //     }
    //     return true;
    // }
    public:
        Request(){}
        Request(int x,int y,char op)
        :_x(x),_y(y),_op(op)
        {

        }
        ~Request(){}
        int _x;
        int _y;
        char _op;
    };

    class Response
    {
    public:
        std::string Seiralize()
        {
            std::string str;
            str=std::to_string(_code);
            str+=SPACE;
            str+=std::to_string(_result);
            str+=SPACE;
            return str;
        }
        std::string Serialize()
        {
            std::string s;
            s=std::to_string(_code);
            s+=SPACE;
            s+=std::to_string(_result);
            return s;
        }
        bool Deserialize(const std::string& str)
        {
            std::size_t pos=str.find(SPACE);
            if(pos==std::string::npos){
                return false;
            }
            _code=atoi(str.substr(0,pos).c_str());
            _result=atoi(str.substr(pos+SPACE_LEN).c_str());
            return true;
        }
        // bool Deserialize(const std::string& str)
        // {
        //     std::size_t pos=str.find(SPACE);
        //     if(pos==std::string::npos){
        //         return false;
        //     }
        //     _code=atoi(str.substr(0,pos).c_str());
        //     _result=atoi(str.substr(pos+SPACE_LEN).c_str());
        //     return true;
        // }
    public:
        Response(){}
        Response(int x,int y,int code,int result,char op)
        :_x(x),_y(y),_op(op)
        ,_code(code),_result(result)
        {

        }
        ~Response(){

        }
        int _result;
        int _code;
        int _x;
        int _y;
        char _op;
    };
}
